Skip to contentMethod: SplitNode(AbstractNode, AbstractNode, AbstractNode)
1: package pruefskript.parser.nodes;
2:
3: import java.util.ArrayList;
4: import java.util.List;
5: import java.util.regex.Pattern;
6:
7: import basic.PruefskriptConstants;
8: import pruefskript.CommunicationManager;
9: import pruefskript.parser.exceptions.CheckScriptException;
10: import pruefskript.parser.exceptions.WrongNodeException;
11: import pruefskript.parser.values.AbstractReturnValue;
12: import pruefskript.parser.values.NumericValue;
13: import pruefskript.parser.values.StringValue;
14: import pruefskript.parser.values.VoidValue;
15:
16: /**
17: * SplitNode, mit Hilfe dieser Aktion koennen Variablen, die mit mehreren Parametern belegt wurden,
18: * aufgeteilt werden.
19: *
20: * @author Group B5
21: *
22: */
23: public class SplitNode extends AbstractQuataryOperationNode {
24:
25: /**
26: * Falls die neuen Teile als String interpretiert werden sollen.
27: *
28: * @param operand1
29: * AbstractNode
30: * @param operand2
31: * AbstractNode
32: * @param operand3
33: * AbstractNode
34: */
35: public SplitNode(final AbstractNode operand1, final AbstractNode operand2,
36: final AbstractNode operand3) {
37: super(operand1, operand2, operand3, new StringNode("String"));
38: }
39:
40: /**
41: * Falls die neuen Teile nummerisch interpretiert werden sollen.
42: *
43: * @param operand1
44: * AbstractNode
45: * @param operand2
46: * AbstractNode
47: * @param operand3
48: * AbstractNode
49: * @param operand4
50: * AbstractNode
51: */
52: public SplitNode(final AbstractNode operand1, final AbstractNode operand2,
53: final AbstractNode operand3, final AbstractNode operand4) {
54: super(operand1, operand2, operand3, operand4);
55: }
56:
57: @Override
58: public String toString() {
59: return PruefskriptConstants.SPLITTILE + PruefskriptConstants.BRACKET_OPEN
60: + super.toString() + PruefskriptConstants.BRACKET_CLOSE;
61: }
62:
63: @Override
64: public boolean equals(final Object obj) {
65: return super.equals(obj) && obj instanceof SplitNode;
66:
67: }
68:
69: @Override
70: public int hashCode() {
71: return super.hashCode() + PruefskriptConstants.SPLITNODE_HASHCODE;
72: }
73:
74: @Override
75: public VoidValue interpret(final CommunicationManager mgr) throws CheckScriptException {
76:
77: final AbstractReturnValue op1 = this.getOperand1().interpret(mgr); // Variable, die getrennt
78: // werden soll.
79: final AbstractReturnValue op3 = this.getOperand3().interpret(mgr); // Trennzeichen
80: final AbstractReturnValue op4 = this.getOperand4().interpret(mgr); // Interpretation numeric
81: // oder other=string
82:
83: if ((this.getOperand1().isIDNode() || this.getOperand1().isIDSetNode())
84: && this.getOperand2().isIDSetNode() && op3.isStringValue()
85: && op4.isStringValue()) {
86:
87: interpretAsSplit(mgr, op1, op3, op4);
88: } else {
89: throw new WrongNodeException(PruefskriptConstants.UNEXPECTED_STRING);
90: }
91: return new VoidValue();
92: }
93:
94: /**
95: * @param mgr
96: * The {@link CommunicationManager} to use.
97: * @param op1
98: * AbstractReturnValue
99: * @param op3
100: * AbstractReturnValue
101: * @param op4
102: * AbstractReturnValue
103: * @throws WrongNodeException
104: * WrongNodeException
105: */
106: private void interpretAsSplit(final CommunicationManager mgr, final AbstractReturnValue op1,
107: final AbstractReturnValue op3, final AbstractReturnValue op4)
108: throws WrongNodeException {
109: final ArrayList<String> splittedParts = new ArrayList<String>();
110: final String s2 = this.getOperand2().toIDSetNode().getName();
111: final String s3 = op3.toStringValue().getValue();
112: final String s4 = op4.toStringValue().getValue();
113:
114: if (op1.isStringValue() || op1.isNumericValue() || op1.isVersionValue()) {
115: final String s1 = op1.getStringRepresentation();
116: splittedParts.addAll(getSplittedParts(s1, s3));
117:
118: } else if (op1.isArrayValue()) {
119: splitArray(op1, splittedParts, s3);
120: }
121: createVariables(mgr, splittedParts, s2, s4);
122: }
123:
124: /**
125: * @param op1
126: * AbstractReturnValue
127: * @param splittedParts
128: * String
129: * @param s3
130: * String
131: * @throws WrongNodeException
132: * WrongNodeException
133: */
134: private void splitArray(final AbstractReturnValue op1, final List<String> splittedParts,
135: final String s3) throws WrongNodeException {
136: final java.util.Iterator<AbstractReturnValue> i =
137: op1.toArrayValue().getValues().iterator();
138: while (i.hasNext()) {
139: final AbstractReturnValue content = i.next();
140: if (content.isStringValue() || content.isNumericValue() || content.isVersionValue()) {
141: splittedParts.addAll(getSplittedParts(content.getStringRepresentation(), s3));
142: } else {
143: throw new WrongNodeException(PruefskriptConstants.NO_NUM_VER_STRING_TYP);
144: }
145: }
146: }
147:
148: /**
149: * @param mgr
150: * The {@link CommunicationManager} to use.
151: * @param splittedParts
152: * String
153: * @param s2
154: * String
155: * @param s4
156: * String
157: * @throws WrongNodeException
158: * .
159: * @throws NumberFormatException
160: * .
161: */
162: private void createVariables(final CommunicationManager mgr, final List<String> splittedParts,
163: final String s2, final String s4) throws NumberFormatException, WrongNodeException {
164: int position = 1;
165: for (String string : splittedParts) {
166: if ("numeric".equals(s4)) {
167: mgr.addValue(s2, position, new NumericValue(Integer.valueOf(string)));
168: } else {
169: mgr.addValue(s2, position, new StringValue(string));
170: }
171: position++;
172: }
173: }
174:
175: /**
176: * .
177: *
178: * @param s1
179: * .
180: * @param s3
181: * .
182: * @return .
183: */
184: private List<String> getSplittedParts(final String s1, final String s3) {
185: final List<String> result = new ArrayList<String>();
186: final String[] stringArray = s1.split(Pattern.quote(s3));
187: for (String string : stringArray) {
188: result.add(string);
189: }
190: return result;
191: }
192: }
![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
